home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung / Power-Programmierung (Tewi)(1994).iso / magazine / msysjour / vol06 / 01 / wintro4 / graph.c < prev    next >
C/C++ Source or Header  |  1990-12-31  |  16KB  |  467 lines
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <windows.h>
  4. #include "stock.h"
  5.  
  6. void FAR PASCAL HandleSelectionState(LPDRAWITEMSTRUCT lpdis, int inflate);
  7. void FAR PASCAL HandleFocusState(LPDRAWITEMSTRUCT lpdis, int inflate);
  8. void FAR PASCAL DrawEntireItem(LPDRAWITEMSTRUCT lpdis, int inflate);
  9.  
  10.  
  11. BOOL FAR PASCAL
  12. GraphOptionsDlgProc(hDlg, message, wParam, lParam)
  13.   HWND hDlg;
  14.   unsigned message;
  15.   WORD wParam;
  16.   LONG lParam;
  17. {
  18.   int         iPen; 
  19.   char        szBuf[80];
  20.   static HANDLE      hStockInfo = NULL;
  21.   static LPSTOCKINFO lpStockInfo = (LPSTOCKINFO) NULL;
  22.   LPGRAPHINFO lpGraphInfo;
  23.   HWND        hWnd;
  24.   BOOL        bTranslated;
  25.  
  26.  
  27.   switch (message)
  28.   {
  29.     case WM_INITDIALOG :
  30.       if ((hStockInfo = (HANDLE) lParam) == NULL)
  31.       {
  32.         EndDialog(hDlg, IDCANCEL);
  33.         return TRUE;
  34.       }
  35.  
  36.       if ((lpStockInfo = (LPSTOCKINFO) GlobalLock(hStockInfo)) == NULL)
  37.       {
  38.         EndDialog(hDlg, IDCANCEL);
  39.         return TRUE;
  40.       }
  41.   
  42.       lpGraphInfo = &lpStockInfo->StockFile.graphinfo;
  43.  
  44.       /*
  45.         If the ticks array has some memory allocated to it, it means
  46.         that we are dealing with an existing stock. If not, then we
  47.         are creating a new stock.
  48.       */
  49.       if (lpStockInfo->hTicks != NULL)
  50.       {
  51.         SetDlgItemText(hDlg, ID_SYMBOL, lpStockInfo->StockFile.szStock);
  52.         SetDlgItemInt(hDlg, ID_MINPRICE, (int) lpGraphInfo->dwMinPrice, FALSE);
  53.         SetDlgItemInt(hDlg, ID_MAXPRICE, (int) lpGraphInfo->dwMaxPrice, FALSE);
  54.         SetDlgItemInt(hDlg, ID_FACTOR, (int) lpGraphInfo->dwScaleFactor, FALSE);
  55.         SetDlgItemInt(hDlg, ID_TICKINT, (int) lpGraphInfo->dwTickInterval, FALSE);
  56.         SetDlgItemInt(hDlg, ID_DENOMINATOR, (int) lpGraphInfo->iDenominator, FALSE);
  57.  
  58.         if (lpStockInfo->dwFlags & STATE_HAS_VGRID)
  59.           CheckDlgButton(hDlg, ID_VERTGRID, TRUE);
  60.         if (lpStockInfo->dwFlags & STATE_HAS_HGRID)
  61.           CheckDlgButton(hDlg, ID_HORZGRID, TRUE);
  62.  
  63.         EnableWindow(GetDlgItem(hDlg, ID_SYMBOL), FALSE);
  64.       }
  65.       else
  66.       {
  67.         lpGraphInfo->iGridPen = 0;
  68.       }
  69.  
  70.  
  71.       /* 
  72.         Fill the listbox with pen ids 
  73.       */ 
  74.       for (iPen = 0;  iPen < PS_NULL;  iPen++) 
  75.         SendDlgItemMessage(hDlg, ID_GRIDSTYLE, CB_ADDSTRING, 0, (LONG) iPen); 
  76.       SendDlgItemMessage(hDlg,ID_GRIDSTYLE,CB_SETCURSEL,lpGraphInfo->iGridPen,0L);
  77.       return TRUE;
  78.  
  79.  
  80.     case WM_MEASUREITEM : 
  81.     { 
  82.       LPMEASUREITEMSTRUCT lpMI = (LPMEASUREITEMSTRUCT) (LPSTR) lParam; 
  83.       lpMI->itemWidth  = 42; 
  84.       lpMI->itemHeight = 20; 
  85.       break; 
  86.     } 
  87.  
  88.     case WM_DRAWITEM : 
  89.     { 
  90.       LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) (LPSTR) lParam; 
  91.  
  92.       if (lpdis->itemID == -1)
  93.       {
  94.         HandleFocusState(lpdis, -5);
  95.         break;
  96.       }
  97.  
  98.       switch (lpdis->itemAction) 
  99.       { 
  100.         case ODA_DRAWENTIRE: 
  101.           DrawEntireItem(lpdis, -4); 
  102.           break; 
  103.  
  104.         case ODA_SELECT: 
  105.           HandleSelectionState(lpdis, 0); 
  106.           break; 
  107.  
  108.         case ODA_FOCUS: 
  109.           HandleFocusState(lpdis, -2); 
  110.           break; 
  111.       } 
  112.  
  113.       break; 
  114.     } 
  115.  
  116.  
  117.     case WM_COMMAND :
  118.       switch (wParam)
  119.       {
  120.         case IDOK :
  121.           lpGraphInfo = &lpStockInfo->StockFile.graphinfo;
  122.  
  123.           if (lpStockInfo->hTicks == NULL)
  124.           {
  125.             GetDlgItemText(hDlg, ID_SYMBOL, szBuf, sizeof(szBuf));
  126.             if (*szBuf == '\0')
  127.             {
  128.               MessageBox(hWndMain, "You must fill in the name of the stock.", "Error", MB_OK);
  129.               return TRUE;
  130.             }
  131.             strcat(szBuf, ".STO");
  132.             lstrcpy(lpStockInfo->szFileName, szBuf);
  133.  
  134.             lpStockInfo->StockFile.dwMagic = MAGIC_COOKIE;
  135.             if ((lpStockInfo->hTicks = GlobalAlloc(GMEM_MOVEABLE, (DWORD) sizeof(TICK) * 64)) == NULL)
  136.             {
  137.               MessageBox(hWndMain, "Can't allocate the ticker array", "Error", MB_OK);
  138.               goto bye;
  139.             }
  140.             lpStockInfo->nTicksAllocated = 64;
  141.             lpStockInfo->StockFile.nTicks = 0;
  142.  
  143.             /*
  144.               Create a window for this guy
  145.             */
  146.             hWnd = lpStockInfo->hWnd = GraphCreateWindow((LPSTR) szBuf);
  147.             SetWindowWord(lpStockInfo->hWnd, 0, hStockInfo);
  148.             lpStockInfo->dwFlags |= STATE_DIRTY;
  149.           }
  150.  
  151.           GetDlgItemText(hDlg, ID_SYMBOL, lpStockInfo->StockFile.szStock, 
  152.                                       sizeof(lpStockInfo->StockFile.szStock));
  153.           lpGraphInfo->dwMinPrice = GetDlgItemLong(hDlg, ID_MINPRICE,
  154.                                       (BOOL FAR *) &bTranslated, FALSE);
  155.           lpGraphInfo->dwMaxPrice = GetDlgItemLong(hDlg, ID_MAXPRICE,
  156.                                       (BOOL FAR *) &bTranslated, FALSE);
  157.           lpGraphInfo->dwScaleFactor = GetDlgItemLong(hDlg, ID_FACTOR,
  158.                                       (BOOL FAR *) &bTranslated, FALSE);
  159.           lpGraphInfo->dwTickInterval = GetDlgItemLong(hDlg, ID_TICKINT,
  160.                                       (BOOL FAR *) &bTranslated, FALSE);
  161.           lpGraphInfo->iDenominator = GetDlgItemInt(hDlg, ID_DENOMINATOR,
  162.                                       (BOOL FAR *) &bTranslated, FALSE);
  163.           lpGraphInfo->iGridPen = (WORD)
  164.                   SendDlgItemMessage(hDlg, ID_GRIDSTYLE, CB_GETCURSEL, 0, 0L);
  165.  
  166.           lpStockInfo->dwFlags &= ~(STATE_HAS_VGRID | STATE_HAS_HGRID);
  167.           if (IsDlgButtonChecked(hDlg, ID_VERTGRID))
  168.             lpStockInfo->dwFlags |= STATE_HAS_VGRID;
  169.           if (IsDlgButtonChecked(hDlg, ID_HORZGRID))
  170.             lpStockInfo->dwFlags |= STATE_HAS_HGRID;
  171.  
  172. bye:
  173.           InvalidateRect(lpStockInfo->hWnd, (LPRECT) NULL, TRUE);
  174.           GlobalUnlock(hStockInfo);
  175.           EndDialog(hDlg, IDOK);
  176.           break;
  177.  
  178.         case IDCANCEL:
  179.           GlobalUnlock(hStockInfo);
  180.           EndDialog(hDlg, IDCANCEL);
  181.           break;
  182.       }
  183.       return TRUE;
  184.  
  185.   } /* end switch (message) */
  186.  
  187.   return FALSE;
  188. }
  189.  
  190.  
  191. /**************************************************************************** 
  192.  *                                                                          * 
  193.  *  FUNCTION   : HandleSelectionState(LPDRAWITEMSTRUCT, int)                * 
  194.  *                                                                          * 
  195.  *  PURPOSE    : Handles a change in an item selection state. If an item is * 
  196.  *               selected, a black rectangular frame is drawn around that   * 
  197.  *               item; if an item is de-selected, the frame is removed.     * 
  198.  *                                                                          * 
  199.  *  COMMENT    : The black selection frame is slightly larger than the gray * 
  200.  *               focus frame so they won't paint over each other.           * 
  201.  *                                                                          * 
  202.  ****************************************************************************/ 
  203. void FAR PASCAL HandleSelectionState(lpdis, inflate) 
  204.   LPDRAWITEMSTRUCT  lpdis; 
  205.   int               inflate; 
  206. { 
  207.   HBRUSH hbr = (lpdis->itemState & ODS_SELECTED) ? GetStockObject(BLACK_BRUSH)
  208.                                 : CreateSolidBrush(GetSysColor(COLOR_WINDOW)); 
  209.   FrameRect(lpdis->hDC, (LPRECT) &lpdis->rcItem, hbr); 
  210.   DeleteObject (hbr); 
  211. } 
  212.  
  213.  
  214. /**************************************************************************** 
  215.  *                                                                          * 
  216.  *  FUNCTION   : HandleFocusState(LPDRAWITEMSTRUCT, int)                    * 
  217.  *                                                                          * 
  218.  *  PURPOSE    : Handle a change in item focus state. If an item gains the  * 
  219.  *               input focus, a gray rectangular frame is drawn around that * 
  220.  *               item; if an item loses the input focus, the gray frame is  * 
  221.  *               removed.                                                   * 
  222.  *                                                                          * 
  223.  *  COMMENT    : The gray focus frame is slightly smaller than the black    * 
  224.  *               selection frame so they won't paint over each other.       * 
  225.  *                                                                          * 
  226.  ****************************************************************************/ 
  227. void FAR PASCAL HandleFocusState(lpdis, inflate) 
  228.   LPDRAWITEMSTRUCT  lpdis; 
  229.   int      inflate; 
  230. { 
  231.   RECT  rc; 
  232.   HBRUSH  hbr; 
  233.  
  234.   /* Resize rectangle to place focus frame between the selection 
  235.    * frame and the item. 
  236.    */ 
  237.   CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem); 
  238.   InflateRect ((LPRECT)&rc, inflate, inflate); 
  239.  
  240.   if (lpdis->itemState & ODS_FOCUS) 
  241.     /* gaining input focus -- paint a gray frame */ 
  242.     hbr = GetStockObject(GRAY_BRUSH); 
  243.   else 
  244.     /* losing input focus -- remove (paint over) frame */ 
  245.     hbr = CreateSolidBrush(GetSysColor(COLOR_WINDOW)); 
  246.  
  247.   FrameRect(lpdis->hDC, (LPRECT)&rc, hbr); 
  248.   DeleteObject (hbr); 
  249. } 
  250.  
  251. /**************************************************************************** 
  252.  *                                                                          * 
  253.  *  FUNCTION   : DrawEntireItem(LPDRAWITEMSTRUCT, int)                      * 
  254.  *                                                                          * 
  255.  *  PURPOSE    : Draws an item and frames it with a selection frame and/or  * 
  256.  *               a focus frame when appropriate.                            * 
  257.  *                                                                          * 
  258.  ****************************************************************************/ 
  259. void FAR PASCAL DrawEntireItem(lpdis, inflate) 
  260.   LPDRAWITEMSTRUCT  lpdis; 
  261.   int      inflate; 
  262. { 
  263.   RECT   rc; 
  264.   HANDLE hOldPen; 
  265.   HPEN   hPen; 
  266.  
  267.   if (lpdis->itemData < 0)
  268.     return;
  269.  
  270.   /* Resize rectangle to leave space for frames */ 
  271.   CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem); 
  272.   InflateRect ((LPRECT)&rc, inflate, inflate); 
  273.  
  274.   if (lpdis->itemState & ODS_FOCUS) 
  275.     hPen = CreatePen((int) lpdis->itemData, 1, RGB(0xFF, 0xFF, 0xFF)); 
  276.   else
  277.     hPen = CreatePen((int) lpdis->itemData, 1, RGB(0, 0, 0)); 
  278.   hOldPen = SelectObject(lpdis->hDC, hPen); 
  279.  
  280. #if 0
  281. {
  282.   char szMsg[80];
  283.   sprintf(szMsg,
  284.   "rc:[%d %d %d %d]  itemID:%d  itemAction:%x  itemState:%x  itemData:%ld",
  285.    rc.left, rc.top, rc.right, rc.bottom, lpdis->itemID, lpdis->itemAction,
  286.    lpdis->itemState, lpdis->itemData);
  287.   MessageBox(hWndMain, szMsg, "DrawEntireItem", MB_OK);
  288. }
  289. #endif
  290.  
  291.   MoveTo(lpdis->hDC, rc.left,  rc.top + (rc.bottom - rc.top) / 2); 
  292.   LineTo(lpdis->hDC, rc.right, rc.top + (rc.bottom - rc.top) / 2); 
  293.  
  294.   SelectObject(lpdis->hDC, hOldPen); 
  295.   DeleteObject(hPen); 
  296.  
  297.   /* Draw or erase appropriate frames */ 
  298.   HandleSelectionState(lpdis, inflate + 4); 
  299.   HandleFocusState(lpdis, inflate + 2); 
  300. } 
  301.  
  302.  
  303. int PASCAL GraphWndPaint(HWND hWnd, HDC hDC, LPSTOCKINFO lpStockInfo)
  304. {
  305.   RECT         r;
  306.   int          i, y;
  307.   int          xGraph, yGraph;
  308.   LPTICK       lpTick;
  309.   int          rangeHigh,
  310.                rangeLow,
  311.                xPixelsPerDate;
  312.   int          yAxisStart, xAxisStart;
  313.   HANDLE       hOldPen;
  314.   HPEN         hPen;
  315.   TEXTMETRIC   tm;
  316.   char         szBuf[80];
  317.  
  318.   if (lpStockInfo->StockFile.nTicks == 0)
  319.     return TRUE;
  320.  
  321.   /*
  322.     Get the client dimensions of the current stock window and figure out the
  323.     width and height of the graph.
  324.   */
  325.   GetClientRect(hWnd, (LPRECT) &r);
  326.   yGraph = r.bottom - r.top;
  327.   xGraph = r.right - r.left;
  328.  
  329.   /*
  330.     Get the low and high range into local variables.
  331.   */
  332.   rangeHigh = (int) lpStockInfo->StockFile.graphinfo.dwMaxPrice;
  333.   rangeLow  = (int) lpStockInfo->StockFile.graphinfo.dwMinPrice;
  334.  
  335.   /*
  336.     Get the metrics of the current font.
  337.   */
  338.   GetTextMetrics(hDC, (LPTEXTMETRIC) &tm);
  339.  
  340.   if ((lpTick = (LPTICK) GlobalLock(lpStockInfo->hTicks)) == NULL)
  341.     return FALSE;
  342.  
  343.  
  344.   /*
  345.     This code is for WINTRO 4
  346.   */
  347.   y = 0;
  348.   for (i = 0;  i < lpStockInfo->StockFile.nTicks;  i++)
  349.   {
  350.     sprintf(szBuf, "%d) Price %ld", i+1, lpTick[i].price);
  351.     TextOut(hDC, 0, y, szBuf, strlen(szBuf));
  352.     y += tm.tmHeight;
  353.   }
  354.   goto bye;
  355.  
  356.  
  357.  
  358.   /*
  359.     Set up the mapping mode. Y-axis points up and X-axis points right.
  360.   */
  361.   SetMapMode(hDC, MM_ANISOTROPIC);
  362.   SetWindowOrg(hDC, 0, 0);
  363.   SetViewportOrg(hDC, 0, yGraph);
  364.   SetWindowExt(hDC,  xGraph, yGraph);
  365.   SetViewportExt(hDC, xGraph, -yGraph);
  366.  
  367.   sprintf(szBuf, "%d", rangeHigh);
  368.   yAxisStart = strlen(szBuf) * (tm.tmAveCharWidth + 1);
  369.   xAxisStart = tm.tmHeight + (tm.tmHeight/2);
  370.   xPixelsPerDate = xGraph / lpStockInfo->StockFile.nTicks;
  371.  
  372.   /*
  373.     Draw the axises. First the Y-axis, then the X-axis.
  374.   */
  375.   MoveTo(hDC, yAxisStart, xAxisStart);
  376.   LineTo(hDC, yAxisStart, yGraph);
  377.   MoveTo(hDC, yAxisStart, xAxisStart);
  378.   LineTo(hDC, xGraph,     xAxisStart);
  379.  
  380.   /*
  381.     Draw the hash marks for the x-axis
  382.   */
  383.   for (i = 1;  i < lpStockInfo->StockFile.nTicks;  i++)
  384.   {
  385.     int x = i * xPixelsPerDate + yAxisStart;
  386.     int iTextLen;
  387.     MoveTo(hDC, x, xAxisStart-2);
  388.     LineTo(hDC, x, xAxisStart+2);
  389.     sprintf(szBuf, "%d", i+1);
  390.     iTextLen = strlen(szBuf) * tm.tmAveCharWidth;
  391.     /*
  392.       Output the x-axis text centered over the hash mark
  393.     */
  394.     TextOut(hDC, x - (iTextLen >> 1), xAxisStart-2, szBuf, strlen(szBuf));
  395.   }
  396.  
  397.   /*
  398.     Draw the hash marks for the y-axis
  399.   */
  400.   for (i = rangeLow;  i < rangeHigh;  i++)
  401.   {
  402.     int y = (i - rangeLow) * yGraph / (rangeHigh - rangeLow) + xAxisStart;
  403.     MoveTo(hDC, yAxisStart-4, y);
  404.     LineTo(hDC, yAxisStart+4, y);
  405.     sprintf(szBuf, "%d", i);
  406.     TextOut(hDC, 0, y + (tm.tmHeight >> 1), szBuf, strlen(szBuf));
  407.   }
  408.  
  409.  
  410.   /*
  411.     Figure out how many pixels wide each entry should be. This is equal
  412.     to the width of the graph divided by the number of ticks to be plotted.
  413.   */
  414.   MoveTo(hDC, yAxisStart, xAxisStart + 
  415.           ((int) lpTick[0].price - rangeLow) * yGraph / (rangeHigh - rangeLow));
  416.   if (lpStockInfo->StockFile.nTicks == 1)
  417.   {
  418.     int x = i * xPixelsPerDate;
  419.     int y = ((int)lpTick[i].price - rangeLow) * yGraph / (rangeHigh-rangeLow);
  420.     Ellipse(hDC, x-2, y-2, x+2, y+2);
  421.   }
  422.   else
  423.   {
  424.     for (i = 1;  i < lpStockInfo->StockFile.nTicks;  i++)
  425.     {
  426.       int x = i * xPixelsPerDate;
  427.       int y = ((int) lpTick[i].price - rangeLow) * yGraph / 
  428.               (rangeHigh - rangeLow);
  429.       LineTo(hDC, x + yAxisStart, y + xAxisStart);
  430.     }
  431.   }
  432.  
  433.   /*
  434.     Now draw the horizontal and vertical grid lines.
  435.   */
  436.   hPen = CreatePen(lpStockInfo->StockFile.graphinfo.iGridPen, 1, RGB(0, 0, 0));
  437.   hOldPen = SelectObject(hDC, hPen);
  438.  
  439.   if (lpStockInfo->dwFlags & STATE_HAS_VGRID)
  440.   {
  441.     for (i = 0;  i < lpStockInfo->StockFile.nTicks;  i++)
  442.     {
  443.       int x = (i+1) * xPixelsPerDate + yAxisStart;
  444.       MoveTo(hDC, x, xAxisStart);
  445.       LineTo(hDC, x, yGraph);
  446.     }
  447.   }
  448.  
  449.   if (lpStockInfo->dwFlags & STATE_HAS_HGRID)
  450.   {
  451.     for (i = rangeLow+1;  i < rangeHigh;  i++)
  452.     {
  453.       int y = (i - rangeLow) * yGraph / (rangeHigh - rangeLow);
  454.       MoveTo(hDC, yAxisStart, y + xAxisStart);
  455.       LineTo(hDC, xGraph, y + xAxisStart);
  456.     }
  457.   }
  458.  
  459.   SelectObject(hDC, hOldPen);
  460.   DeleteObject(hPen);
  461.  
  462. bye:
  463.   GlobalUnlock(lpStockInfo->hTicks);
  464.   return TRUE;
  465. }
  466.  
  467.